GermanWikipedia - /page/entry.mu

Micron Document

<!DOCTYPE html>

<title>Java-Syntax</title>

</head>

<h1 id="firstHeading" class="firstHeading mw-first-heading">Java-Syntax</h1>

</header>

</div>

Die <a href="Syntax" title="Syntax">Syntax</a> der Programmiersprache <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a> ist in der <a href="Java_Language_Specification" title="Java Language Specification">Java Language Specification</a> definiert, ebenso wie die <a href="Semantik" title="Semantik">Semantik</a> von Java.

Dieser Artikel gibt einen Überblick über die Java-Syntax und stellt einige ihrer Besonderheiten heraus. Details sind in den <a href="Java_Language_Specification" title="Java Language Specification">Java-Sprachspezifikation von Sun Microsystems</a> aufgeführt.

<div class="mw-heading mw-heading2"><h2 id="Terminologie">Terminologie</h2></div>

Da Java eine Programmiersprache ist, zu deren Beschreibung überwiegend englischsprachige Begriffe benutzt werden, aber dennoch in der Literatur ebenfalls eingedeutschte Übersetzungen bestimmter Bestandteile verwendet werden, soll an dieser Stelle über die <a href="Disambiguierung" title="Disambiguierung">Mehrdeutigkeit</a> aufgeklärt und ebenfalls die von diesem Artikel verwendeten Ausdrücke festgelegt werden, damit eine Verwechslung ausgeschlossen werden kann. Im Folgenden werden die in diesem Artikel verwendeten Begriffe und ihre englischen oder deutschen Entsprechungen aufgeführt.

<dl><dt>Ausdruck</dt>

<dd>(engl. Expression) Unter einem <a href="Ausdruck_(Programmierung)" title="Ausdruck (Programmierung)">Ausdruck</a> wird ein beliebig komplexes Sprachkonstrukt verstanden, dessen Auswertung einen einzigen wohl definierten Wert ergibt. Im einfachsten Fall ist ein Ausdruck eine Konstante, wie z. B. das Schlüsselwort true oder auch eine Zahl (z. B. 1 oder 0x7fff). Komplexere Ausdrücke sind Vergleiche oder Berechnungen mit mehreren Variablen und Konstanten. Innerhalb der Grammatikbeschreibungen wird hier häufig noch nach verschiedenen Arten von Ausdrücken (z. B. numerisch, literal etc.) unterschieden, was hier nicht der Fall sein soll.</dd>

<dt>Anweisung</dt>

<dd>(engl. Statement, Instruction oder Command; auch Befehl genannt) Eine <a href="Anweisung_(Programmierung)" title="Anweisung (Programmierung)">Anweisung</a> bezeichnet in Java, wie auch in vielen anderen imperativen Programmiersprachen, eine einzelne Vorschrift, die im Rahmen der Abarbeitung des Programms auszuführen ist. Dazu zählen die Deklaration von Variablen, durch Semikolon abgeschlossene Ausdrücke, Kontrollstrukturen, Anweisungsblöcke, Sprunganweisungen, Synchronisierungsblöcke, Rückgaben von Werten und das Auslösen von Ausnahmen.</dd>

<dt>Anweisungsblock</dt>

<dd>(engl. Statement Block) Ein Anweisungsblock dient dazu, mehrere Anweisungen zu gruppieren. Dadurch können mehrere Anweisungen wie eine einzelne Anweisung interpretiert werden, was von einigen Sprachkonstrukten vorausgesetzt wird – wie etwa von den Kontrollstrukturen.</dd></dl>

<div class="mw-heading mw-heading2"><h2 id="Lexikalische_Struktur">Lexikalische Struktur</h2></div>

Java-Programme werden in <a href="Unicode" title="Unicode">Unicode</a> geschrieben.

Im Gegensatz zu anderen Sprachen können Bezeichner (englisch Identifier) von Klassen, Methoden, Variablen usw. nicht nur die Buchstaben des lateinischen Alphabets und Ziffern enthalten, sondern auch Zeichen aus anderen Alphabeten, wie z. B. deutsche Umlaute oder chinesische Schriftzeichen.

Sämtliche Schlüsselwörter in Java werden klein geschrieben, z. B. „<code>class</code>“ oder „<code>if</code>“.

Buchstabensymbole (englisch literals) sind in Java die kleinstmöglichen Ausdrücke für Zahlen, einzelne Zeichen, Zeichenketten (Strings), logische Werte (<code>true</code> oder <code>false</code>) und das spezielle Wort <code>null</code>.

Trennzeichen (englisch separators) sind verschiedene Arten von Klammern sowie Komma, Punkt und Semikolon.

Java kennt die in Programmiersprachen üblichen <a href="Logischer_Operator" title="Logischer Operator">logischen</a>, <a href="Vergleichsoperator" title="Vergleichsoperator">Vergleichs-</a> und <a href="Operator_(Mathematik)" title="Operator (Mathematik)">mathematischen Operatoren</a>. Die Syntax orientiert sich dabei an der <a href="C%2B%2B" title="C++">Programmiersprache C++</a>. So dient zum Beispiel das einfache Gleichheitszeichen „<code>=</code>“ als Zuweisungsoperator, während für Vergleiche das doppelte Gleichheitszeichen „<code>==</code>“ verwendet wird.

Leerzeichen, Zeilenenden und Kommentare können an beliebigen Stellen zwischen den Bezeichnern, Schlüsselwörtern, Buchstabensymbolen, Trennzeichen und Operatoren eingefügt werden.

<div class="mw-heading mw-heading2"><h2 id="Syntax">Syntax</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Datentypen">Datentypen</h3></div>

Java kennt zwei <a href="Datentyp" title="Datentyp">Datentyparten</a>: primitiver Datentyp und <a href="Referenz_(Programmierung)" title="Referenz (Programmierung)">Referenzen</a> auf Objekte. Die primitiven Datentypen sind ein Grund, weshalb Java strenggenommen keine reine objektorientierte Sprache ist.

<div class="mw-heading mw-heading4"><h4 id="Primitive_Datentypen">Primitive Datentypen</h4></div>

Es gibt acht primitive Datentypen. Sie haben unterschiedliche Größen und Eigenschaften und werden zum Berechnen und Speichern diskreter Zahlenwerte benutzt. Alle diese Datentypen verfügen über eine fest definierte Größe, die für alle Plattformen gleich ist. Für jeden Typ existiert eine entsprechende <a href="Adapter_(Entwurfsmuster)" title="Adapter (Entwurfsmuster)">Wrapper</a>-Klasse, um auch diese als echte Objekte behandeln zu können.

<th>Datentyp

</th>

<th>Größe<style data-mw-deduplicate="TemplateStyles:r261937660">

/* start https://de.wikipedia.org/ */

.mw-parser-output .fussnoten-marke{font-style:normal;font-variant:normal;font-weight:normal;unicode-bidi:isolate;white-space:nowrap}.mw-parser-output sup.fussnoten-marke{font-size:0.75rem}.mw-parser-output .fussnoten-etui sup{margin-left:-0.15rem}.mw-parser-output span.fussnoten-inhalt{padding-left:0.1rem}.mw-parser-output span.fussnoten-inhalt+span.fussnoten-inhalt{padding-left:0.15rem}.mw-parser-output .fussnoten-block{margin-bottom:0.1rem}.mw-parser-output div.fussnoten-inhalt{display:inline-block;padding-left:0.8rem;text-indent:-0.8rem}.mw-parser-output div.fussnoten-inhalt p,.mw-parser-output div.fussnoten-inhalt dl,.mw-parser-output div.fussnoten-inhalt ol,.mw-parser-output div.fussnoten-inhalt ul{text-indent:0}.mw-parser-output div.fussnoten-inhalt.fussnoten-floatfix{display:block}.mw-parser-output .fussnoten-box{margin-top:0.5rem;padding-left:0.8rem}.mw-parser-output .fussnoten-box,.mw-parser-output div.fussnoten-inhalt{font-size:94%}.mw-parser-output .fussnoten-box div.fussnoten-inhalt,.mw-parser-output span.fussnoten-inhalt,.mw-parser-output .fussnoten-inhalt .reference-text{font-size:inherit}.mw-parser-output .fussnoten-inhalt .reference-text{display:inline}.mw-parser-output .fussnoten-linie{display:inline-block;position:relative;top:-1em;border-top:solid 1px #808080;width:8rem}.mw-parser-output .fussnoten-linie+p,.mw-parser-output .fussnoten-linie+dl,.mw-parser-output .fussnoten-linie+ol,.mw-parser-output .fussnoten-linie+ul,.mw-parser-output .fussnoten-linie+link+div{margin-top:-1em}.mw-parser-output .annotationpair-m:target .fussnoten-marke,.mw-parser-output .fussnoten-inhalt:target{background-color:var(--background-color-progressive-subtle,#f1f4fd);box-shadow:0 0 0 0.25em var(--background-color-progressive-subtle,#f1f4fd)}.mw-parser-output .annotationpair-m:target .fussnoten-marke,.mw-parser-output .fussnoten-inhalt:target .fussnoten-marke{font-weight:bold}

/* end https://de.wikipedia.org/ */

</style> (a)

</th>

<th>Wrapper-Klasse

</th>

<th>Wertebereich

</th>

<th>Beschreibung

</th></tr>

<tr>

<td>boolean</td>

<td>java.lang.Boolean

</td>

<td>true / false

</td>

<td><a href="Boolesche_Algebra" title="Boolesche Algebra">Boolescher Wahrheitswert</a>

</td></tr>

<tr>

<td>java.lang.Character

</td>

<td>U+0000 … U+FFFF

</td>

<td><a href="Unicode" title="Unicode">Unicode</a>-Zeichen (= Symbol) (z. B. <code>'A'</code> oder <code>'\uC3A4'</code>)

</td></tr>

<tr>

<td>java.lang.Byte

</td>

<td>−128 … +127

</td>

<td><a href="Zweierkomplement" title="Zweierkomplement">Zweierkomplement</a>-Wert

</td></tr>

<tr>

<td>short</td>

<td>java.lang.Short

</td>

<td>−32.768 … +32.767

</td>

<td>Zweierkomplement-Wert

</td></tr>

<tr>

<td>java.lang.Integer

</td>

<td>−2.147.483.648 … +2.147.483.647

</td>

<td>Zweierkomplement-Wert

</td></tr>

<tr>

<td>java.lang.Long

</td>

<td>−9.223.372.036.854.775.808 … +9.223.372.036.854.775.807

</td>

<td>Zweierkomplement-Wert

</td></tr>

<tr>

<td>float</td>

<td>java.lang.Float

</td>

<td>±1,4E−45 … ±3,4E+38

</td>

<td><a href="Gleitkommazahl" title="Gleitkommazahl">Gleitkommazahl</a> (<a href="IEEE_754" title="IEEE 754">IEEE 754</a>)

</td></tr>

<tr>

<td>double</td>

<td>java.lang.Double

</td>

<td>±4,9E−324 … ±1,7E+308

</td>

<td>Gleitkommazahl doppelter Genauigkeit (IEEE 754)

</td></tr></tbody></table>

<div class="fussnoten-block"><div class="fussnoten-inhalt references">(a) <div class="reference-text">Gibt die Größe des Wertebereichs an. Der tatsächliche Speicherbedarf ist abhängig von Plattform und Implementierung der Java Virtual Machine.</div></div></div>

</div>

<div class="mw-heading mw-heading5"><h5 id="Typumwandlung">Typumwandlung</h5></div>

Die Hierarchie für das <a href="Typumwandlung" title="Typumwandlung">Umwandeln</a> (type casting) der primitiven Datentypen lässt sich aus der oberen Tabelle erahnen.

Die numerischen Datentypen lassen sich verlustfrei in den nächstgrößeren Datentyp umrechnen, jedoch nicht umgekehrt.

So kann ein „<code>int</code>“ implizit, also ohne speziellen Operator, in ein „<code>long</code>“ umgewandelt werden, jedoch nicht umgekehrt.

long l = i;

</pre></div>

Um jedoch in umgekehrter Richtung beispielsweise einen „<code>long</code>“ in ein „<code>int</code>“ umzuwandeln, muss der Typumwandlungsoperator verwendet werden. Dabei können auch Informationen verloren gehen.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>long l = 12345678901L;

int i = (int) l;

</pre></div>

Hier tritt ein Informationsverlust auf: „<code>i</code>“ hat nach der Zuweisung den Wert −539222987, weil die höherwertigen Bytes abgeschnitten werden.

Der primitive Datentyp „<code>boolean</code>“ kann in keinen anderen Datentyp umgewandelt werden. Zeichen vom Typ „<code>char</code>“ können implizit in jeden ganzzahligen Typ ab „<code>int</code>“ umgewandelt werden. Dies hängt insbesondere damit zusammen, dass „<code>char</code>“ den einzigen in Java bekannten vorzeichenlosen Datentyp darstellt. Damit ist eine verlustfreie Konvertierung nach „<code>short</code>“ ab dem Wert 32768 nicht mehr möglich.

<div class="mw-heading mw-heading4"><h4 id="Referenzen">Referenzen</h4></div>

Alle Objekte und <a href="Feld_(Java)" class="mw-redirect" title="Feld (Java)">Felder</a> liegen im <a href="Dynamischer_Speicher" title="Dynamischer Speicher">Heap</a>-Speicher und werden deshalb über eine Adresse referenziert. Der Objektzugriff in Java ist über <a href="Referenz_(Programmierung)" title="Referenz (Programmierung)">Referenzen</a> implementiert, welche den aus C/C++ bekannten Zeigern ähneln.<a href="#cite_note-1">[1]</a> Die Sprachdefinition (Java Language Specification) bezeichnet sie als „Reference Values“, um deutlich zu machen, dass sie durch <a href="Wertparameter" title="Wertparameter">Call-by-Value</a> übergeben werden.<a href="#cite_note-sun-reference-value-2">[2]</a> In Java gibt es keine direkte Möglichkeit, die Speicheradresse einer Referenz anzuzeigen oder diese zu modifizieren, wodurch sogenannte Zeigerarithmetik in Java ausgeschlossen wird.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>Object a = new Object(); // a referenziert das gerade neu erstellte Objekt

Object b = a; // b referenziert dasselbe Objekt wie a

a = null; // a referenziert kein Objekt mehr, enthält somit die reservierte Adresse null.

</pre></div>

Hierbei gilt es festzuhalten, dass auch Zeichenketten (Klasse <code>String</code>) Referenztypen darstellen und daher inhaltlich stets über die Methode <code>equals()</code> zu vergleichen sind („<code>==</code>“ kontrolliert nur die Referenzen, d. h. Speicheradressen). Dies steht im Gegensatz zu Programmiersprachen wie C++ und <a href="C-Sharp" title="C-Sharp">C#</a>, welche die vollständige Operatorenüberladung unterstützen und bei <code>"hallo"=="hallo"</code> Inhaltsvergleiche durchführen.

<div class="mw-heading mw-heading3"><h3 id="Reservierte_Wörter">Reservierte Wörter</h3></div>

<code>const</code> und <code><a href="Sprunganweisung" title="Sprunganweisung">goto</a></code> sind zwar reserviert, aber ohne Funktion, also keine Schlüsselwörter im eigentlichen Sinn. Sie dienen lediglich dem Compiler zur Ausgabe sinnvoller Fehlermeldungen für Umsteiger von C++ oder C.

<code>true</code>, <code>false</code> und <code>null</code> sind Literale, jedoch ebenfalls eigentlich keine Schlüsselwörter im engeren Sinn.

Mit <code>assert</code> werden <a href="Assertion_(Informatik)" title="Assertion (Informatik)">Assertions</a> realisiert.

<code>private</code>, <code>protected</code> und <code>public</code> sind <a href="Zugriffsmodifikator" title="Zugriffsmodifikator">Zugriffsmodifikatoren</a> (access modifier):

<th>Die Klasse selbst</th>

<th>Paket-Klassen/ innere Klassen</th>

<th>Unterklassen</th>

<th>Sonstige Klassen

</th></tr>

<tr>

<th style="text-align:left;">private

</th>

<td>Nein

</td></tr>

<tr>

</td>

<td>Nein

</td></tr>

<tr>

<th style="text-align:left">protected

</th>

<td>Nein

</td></tr>

<tr>

<th style="text-align:left">public

</th>

<td>Ja

</td></tr></tbody></table>

<li id="cite_note-3"><a href="#cite_ref-3">↑</a> Um inneren Klassen den Zugriff auf private Methoden und Eigenschaften dennoch zu ermöglichen,

werden vom Compiler statische, paket-private Methoden erstellt, die den Aufruf, das Setzen oder das Auslesen emulieren. Diese Methoden tragen den Namen <code>access$xxx</code>, wobei <code>xxx</code> für eine fortlaufende Nummer steht.

</li>

<li id="cite_note-4"><a href="#cite_ref-4">↑</a> Häufig auch als „package private“ bezeichnet, obwohl es diesen Zugriffsmodifikator nicht gibt.

</li>

</ol>

Private Methoden sind von der Polymorphie ausgenommen, d. h. die Definition einer Methode derselben Signatur in einer Subklasse gilt nicht als Überschreiben (sondern als Verbergen).

<code>static</code> kennzeichnet Implementierungen, die ohne eine Objektreferenz verwendbar sind. Das Schlüsselwort wird bei der Deklaration von Feldern, Methoden und inneren Klassen verwendet. Felder, Methoden und Klassen, die mittels <code>static</code> gekennzeichnet sind, werden im Kontext der <a href="Klasse_(Programmierung)" class="mw-redirect" title="Klasse (Programmierung)">Klasse</a> verwendbar und sind an kein <a href="Objekt_(Programmierung)" title="Objekt (Programmierung)">Objekt</a> gekoppelt.

<code>abstract</code> kann vor Klassen und <a href="Methode_(Programmierung)" title="Methode (Programmierung)">Methoden</a> stehen. Abstrakte Methoden verfügen über keine Implementierung und müssen in abgeleiteten Klassen überschrieben werden. Klassen, die abstrakte Methoden enthalten, müssen selbst als abstrakt deklariert werden. Abstrakte Klassen können nicht instanziiert werden, auch wenn sie vollständig implementiert sind, wie z. B. im Fall der EventListener-Adapterklassen des <a href="Swing_(Java)" title="Swing (Java)">Swing</a>-Frameworks.

<code>final</code> kann vor <a href="Variable_(Programmierung)" title="Variable (Programmierung)">Variablen</a>, Feldern, Methoden und Klassen stehen und erzwingt Unveränderlichkeit. Bei Variablen und Membervariablen ihre Konstanz, bei Methoden die Unmöglichkeit, sie in abgeleiteten Klassen zu überschreiben und schließlich bei Klassen, dass von ihnen keine weiteren Ableitungen erfolgen können. Einer finalen Variable wird einmalig ein Wert zugewiesen, der nachträglich nicht mehr verändert werden kann. Eine finale Variable muss nicht in der Deklaration initialisiert werden, sondern kann auch erst in folgenden, alternativen Anweisungen einmalig belegt werden:

final int b; // hier findet noch keine Zuweisung statt

switch (a) {

case 1:

b = 7;

break;

case 2:

b = 3;

break;

default:

b = 1;

break;

}

return b;

}

</pre></div>

Zugriffe auf finale Variablen, deren Wert dem Compiler bekannt ist, dürfen vom Compiler durch den Wert der Variable ersetzt werden. Aufrufe finaler Methoden dürfen vom Compiler durch eingebundenen Code (Inlining) ersetzt werden. Private Methoden sind automatisch final.

<code>native</code> kann nur vor Methoden stehen und bedeutet, dass die Implementierung der betreffenden Methode nicht in Java, sondern einer anderen Programmiersprache geschrieben wurde, und von der virtuellen Maschine über eine <a href="Laufzeitbibliothek" title="Laufzeitbibliothek">Laufzeitbibliothek</a> eingebunden werden muss.

<code>strictfp</code> kennzeichnet Klassen und Methoden, deren enthaltene Gleitkommaoperationen streng nach <a href="IEEE_754" title="IEEE 754">IEEE 754</a> ablaufen müssen.

<code>package</code> deklariert die Paketzugehörigkeit eines komplexen Datentyps. Die Namensgebung eines Pakets sollte eindeutig sein und orientiert sich meist an der <a href="Domain_(Internet)" title="Domain (Internet)">Internet-Domain</a> des Eigentümers oder Erstellers.

<code>import</code> importiert Symbole (vorher nur Typen, ab Java 5 auch statische Member von Klassen), so dass sie ohne voll qualifizierten Namen verwendet werden können. Der Import kann hierbei über das Wildcard <code>*</code> auf komplette Pakete ausgedehnt werden.

<code>boolean</code>, <code>char</code>, <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, <code>float</code> und <code>double</code> sind Typen. <code>void</code> ist der Nichtstyp, notwendig, um Methoden ohne Rückgabewerte zu kennzeichnen. Für die primitiven Typen: siehe oben.

<code>class</code>, <code>interface</code>, <code>enum</code> und <code>@interface</code> dienen zur Deklaration eigener Typen: Klassen, Interfaces (Schnittstellen für Klassen), Enums (<a href="Aufz%C3%A4hlungstyp" title="Aufzählungstyp">Aufzählungstyp</a> für typsichere Aufzählung, englisch typesafe enumeration) und Annotations für Metadaten. <code>enum</code> und <code>@interface</code> sind mit Java 5 in die Sprache aufgenommen worden.

<code>try</code>, <code>catch</code>, <code>finally</code>, <code>throw</code>, <code>throws</code> beziehen sich auf die <a href="Ausnahmebehandlung" title="Ausnahmebehandlung">Ausnahmebehandlung</a> (englisch exception handling). Mit <code>throw</code> wird eine Ausnahme ausgelöst. Alle eventuell ausgelösten Ausnahmen einer Methode, die nicht von <code>RuntimeException</code> oder <code>Error</code> abstammen, müssen mit <code>throws</code> in der Deklaration der Methode angegeben werden. Es handelt sich also um so genannte checked exceptions. <code>try</code> umschließt einen Block, in dem eventuell eine Ausnahme auftreten könnte. <code>catch</code> fängt nach einem <code>try</code>-Block die dort aufgetretene Ausnahme ab, <code>finally</code> wird an einen <code>try</code>- oder <code>catch</code>-Block für Aufräumarbeiten wie das Schließen von Dateien angehängt.

<code>extends</code> und <code>implements</code> dienen der Vererbung: <code>extends</code> der genetischen Erweiterungsvererbung von Klasse zu Klasse oder Interface zu Interface und <code>implements</code> der Implementierungsvererbung von Interface zu Klasse. Außerdem wird <code>extends</code> bei Generics für Typerweiterung verwendet.

<code>super</code> und <code>this</code> beziehen sich im Objekt-Kontext auf das aktuelle Objekt in seinem tatsächlichen Morph (<code>this</code>) oder im Morph der Superklasse (<code>super</code>). <code>this</code> wird verwendet, um in Konstruktoren überladene Konstruktoren aufzurufen und um in Membern auf verdeckte Member äußerer Strukturen zu verweisen. <code>super</code> wird in Konstruktoren zum Aufruf des Superklassenkonstruktors und in überschreibenden Methoden zum Aufruf der überschriebenen Methode verwendet. Außerdem wird <code>super</code> bei Generics für Typeingrenzung verwendet.

<code>new</code> reserviert Speicher für neue Objekte (inklusive Arrays) auf dem <a href="Dynamischer_Speicher" title="Dynamischer Speicher">Heap</a>.

<code>if</code>, <code>else</code>, <code>switch</code>, <code>case</code>, <code>default</code>, <code>while</code>, <code>do</code>, <code>for</code>, <code>break</code>, <code>continue</code> dienen der Bedingungsprüfung und Schleifensteuerung und bedienen sich einer imperativen Syntax.

<code>return</code> liefert Werte aus einer Methode an die aufrufende Methode zurück.

<code>volatile</code> ist ein Modifikator für nicht-lokale Variablen und verbietet dem <a href="Just-in-time-Kompilierung" title="Just-in-time-Kompilierung">JIT-Compiler</a> Registeroptimierungen auf diese Variable, weil mehrere Threads sie gleichzeitig verwenden könnten (insbesondere im Kontext nativer Methoden).

<code>synchronized</code> kennzeichnet einen <a href="Kritischer_Abschnitt" title="Kritischer Abschnitt">kritischen Abschnitt</a> im Quelltext, der nur von einem <a href="Thread_(Informatik)" title="Thread (Informatik)">Thread</a> gleichzeitig ausgeführt werden darf. Ein <a href="Monitor_(Informatik)" title="Monitor (Informatik)">Monitor</a> sperrt den Abschnitt, sobald ihn ein Thread betritt. Versucht ein anderer Thread den gesperrten Abschnitt zu betreten, blockiert dieser Thread so lange, bis der Monitor den Abschnitt freigibt. Jedes beliebige Java-Objekt kann als Monitor verwendet werden. Ist eine Methode mit <code>synchronized</code> gekennzeichnet, wird automatisch das Objekt bzw. bei statischen Methoden das Klassenobjekt als Monitor verwendet.

<code>transient</code> kennzeichnet nicht-persistente Variablen, die nicht serialisiert werden dürfen.

<code>instanceof</code> ist ein Java-Operator, der prüft, ob ein Objekt Exemplar eines angegebenen Typs oder Subtyps ist.

<div class="mw-heading mw-heading3"><h3 id="Pakete,_Namen,_Klassen,_Schnittstellen">Pakete, Namen, Klassen, Schnittstellen</h3></div>

Ein Java-Paket (englisch package) enthält mehrere Klassen, Schnittstellen und Ausnahmen und bildet einen eigenen <a href="Namensraum" title="Namensraum">Namensraum</a>.

Java-Quelltext ist auf mehrere Übersetzungseinheiten (englisch compilation units) aufgeteilt, von denen jede in einer eigenen Datei abgelegt ist. Jede einzelne Übersetzungseinheit definiert als erstes das Paket, dem sie angehört, importiert dann mehrere Klassen oder Schnittstellen aus anderen Paketen, und definiert schließlich eine oder mehrere Klassen und Schnittstellen.

Java unterscheidet einfache Namen, die nur aus einem Bezeichner bestehen, und vollqualifizierte Namen, die aus einer Reihe von Bezeichnern bestehen, die durch Punkte getrennt sind. Die einfachen Namen sind nur ein Hilfsmittel, das dem Programmierer Tipparbeit ersparen und die Lesbarkeit des Programms erhöhen soll. Der Compiler übersetzt sie immer in vollqualifizierte Namen.

Das folgende Beispiel zeigt ein <a href="Hallo-Welt-Programm" title="Hallo-Welt-Programm">Hallo-Welt-Programm</a> in Java.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>package org.wikipedia;

import static java.lang.System.out;

public class HalloWelt {

public static void main(String[] arguments) {

out.println("Hallo Welt.");

}

}

</pre></div>

In diesem Beispiel wird eine Klasse „<code>HalloWelt</code>“ definiert, die dem Paket „<code>org.wikipedia</code>“ angehört. Per Konvention orientieren sich die Paketnamen in Java an den <a href="Dom%C3%A4ne_(Internet)" class="mw-redirect" title="Domäne (Internet)">Internet-Domänen</a> ihrer Entwickler, in diesem Fall also „<code>org.wikipedia</code>“ für die Domäne „<code>wikipedia.org</code>“. Die Richtung des Namens wird umgedreht, weil bei Internet-Domänen der Name der äußersten Einheit hinten steht, während er in Java vorne steht. Das Paket „<code>org.wikipedia</code>“ befindet sich also „innerhalb“ des Pakets „<code>org</code>“.

Eine Import-Anweisung definiert einen einfachen Namen für einen vollqualifizierten Namen. So definiert z. B. die Anweisung „<code>import java.io.File</code>“ den einfachen Namen „<code>File</code>“ für die Klasse, die mit vollem Namen „<code>java.io.File</code>“ heißt.

Neben Imports von Klassen und Schnittstellen können seit Java Version 5 auch statische Felder oder Methoden von Klassen importiert werden. Ein solcher „statischer Import“ wird durch das zusätzliche Schlüsselwort „<code>static</code>“ festgelegt. Im obigen Beispiel wird das statische Feld „<code>out</code>“ der Klasse „<code>java.lang.System</code>“ importiert und anschließend unter dem kurzen Namen „<code>out</code>“ verwendet.

Das wichtigste Konstrukt der Programmiersprache Java ist, da sie eine objektorientierte Sprache ist, die <a href="Klasse_(objektorientierte_Programmierung)" class="mw-redirect" title="Klasse (objektorientierte Programmierung)">Klasse</a>. Die <a href="Deklaration_(Programmierung)" title="Deklaration (Programmierung)">Deklaration</a> einer Klasse wird mit dem Schlüsselwort „<code>class</code>“ eingeleitet. Anschließend folgt der Name der Klasse und dann werden – in geschweiften Klammern – die Felder und Methoden der Klasse definiert.

Eine Besonderheit von Java stellt die Schnittstelle dar. Eine solche Schnittstelle besteht nur aus Methoden-Deklarationen, deren Implementierung erst von den Klassen festgelegt werden, die sie „implementieren“. Die Deklaration einer Schnittstelle sieht ähnlich aus wie die Deklaration einer Klasse, sie wird jedoch mit dem Schlüsselwort „<code>interface</code>“ eingeleitet.

public interface Article {

String getName();

void setContent(String aContent);

}

</pre></div>

Da alle Methoden einer Schnittstelle abstrakt sind, kann das Schlüsselwort „<code>abstract</code>“ bei den einzelnen Methoden entfallen. Ebenso kann das Schlüsselwort „<code>public</code>“ vor den einzelnen Methoden entfallen, weil Methoden einer Schnittstelle immer öffentlich sind.

Ab Java 8 kommt die Möglichkeit hinzu, in Schnittstellen statische Methoden sowie „<code>default</code>“-Methoden zu definieren. Darüber hinaus können Schnittstellen mit der Annotation „<code>@FunctionalInterface</code>“ versehen werden, um anzuzeigen, dass es sich bei ihr um eine funktionale Schnittstelle handelt. Eine solche ist dadurch definiert, dass sie genau eine abstrakte Methode deklariert; die Annotation ist nicht dafür erforderlich. Funktionale Schnittstellen können kurz und bündig durch Lambda-Ausdrücke oder Methodenreferenzen implementiert werden.

<div class="mw-heading mw-heading3"><h3 id="Methoden">Methoden</h3></div>

Das eigentliche Verhalten eines Objekts wird in Methoden definiert. Die <a href="Signatur_(Programmierung)" title="Signatur (Programmierung)">Signatur</a> einer Methode besteht aus ihrem Namen und den Typen ihrer Parameter. Außerdem hat jede Methode einen bestimmten Rückgabetyp oder „<code>void</code>“, wenn sie nichts zurückgibt, und kann eine Reihe von Ausnahmen in einer so genannten „<code>throws</code>“-Klausel definieren.

Beispiel einer konkreten Methode:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public double summe(double a, double b) throws NotANumberException {

if (Double.isNaN(a) || Double.isNaN(b)) {

throw new NotANumberException();

}

return a + b;

}

</pre></div>

Diese Methode erwartet zwei doppelt genaue <a href="Gleitkommazahl" title="Gleitkommazahl">Gleitkommazahlen</a> als Parameter und gibt die Summe der beiden ebenfalls als Gleitkommazahl zurück. Falls eine der beiden Zahlen keine gültige Gleitkommazahl ist, wirft die Methode eine Ausnahme namens „<code>NotANumberException</code>“.

Beispiel einer abstrakten Methode:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>public abstract double summe(double a, double b) throws NotANumberException;

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Attribute">Attribute</h3></div>

<a href="Attribut_(UML)" title="Attribut (UML)">Attribute</a> sind Variablen, die zu einem Objekt gehören. Sie sind durch einen Typ und einen Namen definiert und können wahlweise bereits wenn das Objekt erzeugt wird initialisiert werden.

Beispiel einer Variablendeklaration ohne Initialisierung:

</pre></div>

Klassenvariablen werden als statische Attribute deklariert. Diese Attribute existieren nicht einmal pro Objekt, sondern nur einmal pro Klasse. Das Schlüsselwort „<code>final</code>“ verhindert, dass eine Variable nach ihrer Initialisierung ihren Wert ändert. Es wird zum Beispiel verwendet, um Konstanten zu definieren.

Beispiel einer statischen und finalen Klassenvariablendeklaration mit Initialisierung:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>private static final int X = 2;

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Felder">Felder</h3></div>

In der <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Programmiersprache Java</a> ist ein <a href="Feld_(Datentyp)" class="mw-redirect" title="Feld (Datentyp)">Feld</a> (englisch Array) ein eigenständiges Objekt. Dieses kann Daten eines bei der Deklaration festgelegten Typs aufnehmen. Der Speicher wird erst bei der Initialisierung des Feldes belegt. Dazu muss eine Länge (englisch Size) angegeben werden, die beschreibt wie viele Elemente eines Typs das Feld besitzen soll. Die Größe eines Arrays ist fix und kann nach der Instanziierung nicht mehr geändert werden. In Java wird ein Feld immer mit einem positiven Integer indiziert. Dadurch beschränkt sich die mögliche Länge eines Arrays auf 0 bis 231 − 1.

Die einzelnen Elemente eines Feldes werden – analog zu den Attributen anderer Objekte – bei der Instanziierung des Feldes mit dem Nullwert des jeweiligen Feld-Grundtyps initialisiert. Für Felder von numerischen Primitivtypen ist dies 0 bzw. 0.0, für ein Feld mit dem Grundtyp boolean ist es der Wert <code>false</code>, für Felder von Objektreferenzen die leere Referenz <code>null</code>. Bei der Erzeugung eines Feldes von Objektreferenzen werden also außer dem Feld selbst noch keine Objekte erzeugt.

Echte mehrdimensionale Felder gibt es in Java nicht. Dennoch ist es möglich, mehrdimensionale Felder zu erstellen, indem Felder in Feldern verschachtelt werden. Im Falle eines zweidimensionalen Feldes wird hier zunächst ein Feld erstellt, welches Referenzen auf Felder des gewünschten Typs aufnehmen kann. Anschließend wird jedem Platz dieses Feldes eine Referenz auf ein eindimensionales Feld des gewünschten Grundtyps zugewiesen.

<div class="mw-heading mw-heading4"><h4 id="Eindimensionales_Feld">Eindimensionales Feld</h4></div>

Deklaration

<Datentyp> <Variablenbezeichner>[]; // Alternative Deklaration (seltener verwendet)

</pre></div>

Bei der Deklaration wird der Datentyp des Feldes festgelegt. Dabei wird jedoch kein Feld allokiert, sondern wie bei allen anderen Objekten nur eine Referenz eines Types definiert, der ein Feld zugewiesen werden kann.

Instanziierung

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><Variablenbezeichner> = new <Datentyp>[<Anzahl>]; // Instanziierung eines eindimensionalen Feldes

</pre></div>

Bei der <a href="Objekt_(Programmierung)#Instanziierung" title="Objekt (Programmierung)">Instanziierung</a> eines eindimensionalen Feldes muss sowohl dessen Datentyp als auch die Anzahl der Elemente bekannt sein. Wie bereits am Anfang angemerkt ist die Länge eines Feldes auf nichtnegative ganzzahlige Werte beschränkt. Das Schlüsselwort <code>new</code> hat hier dieselbe Bedeutung wie bei allen anderen Objekten und legt eine Instanz des Typs an. Dabei wird der benötigte Speicher für das Objekt als auch für dessen Elemente reserviert. Im Gegensatz zu anderen Objekten verfügen Felder aber über keine Konstruktoren und es ist nicht möglich, durch explizite Ableitung Subtypen eines Feldtyps zu bilden.

Beispiel eines eindimensionalen Feldes des Typs int der Länge 3

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[] feld = new int[3]; // auf der linken Seite wird die Objektreferenz deklariert

// auf der rechten Seite wird das Feld initialisiert

</pre></div>

Die Deklaration und Instanziierung muss nicht getrennt voneinander erfolgen, sondern kann wie üblich auch als eine Anweisung geschrieben werden. Beim Zugriff auf die Elemente ist zu beachten, dass Java mit dem Index 0 anfängt zu zählen. So wird in diesem Beispiel mit Index 0 auf das erste Element zugegriffen und mit Index 2 auf das letzte Element.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[] feld = {1,2,3}

</pre></div>

ist eine Verkürzung von

feld[0]=1;

feld[1]=2;

feld[2]=3;

</pre></div>

Auslesen von Werten

objekt.methode(feld[1]); // Einzelwerte eines Feldes können wie Variablen des gleichen Typs verwendet werden

int b = feld[3]; // würde in diesem Beispiel eine IndexOutOfBoundsException auslösen, da es kein 4. Element gibt

</pre></div>

Zuweisung von Werten

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>feld[0] = 5; // Java ist "nullbasiert"

feld[1] = (int) 2.7; // bei Zuweisungen muss wie bei normalen Variablen der Typ angepasst werden

feld[2] = 0; // die Indexierung läuft immer bis n-1

</pre></div>

Länge eines Feldes

Viele Algorithmen benötigen die Länge eines Feldes, etwa um alle Einträge abzuarbeiten. Die Länge eines Feldes ist zur Laufzeit bekannt und kann über die Objektvariable <code>length</code> abgefragt werden, die selbst vom Typ <code>int</code> ist. Diese Variable ist stets konstant und kann nicht geändert werden. Eine Zuweisung eines anderen Wertes ist also nicht möglich.

feld.length = 5; // diese Zuweisung würde einen Fehler beim Kompilieren ergeben, da sie nicht zulässig ist

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Mehrdimensionale_Felder">Mehrdimensionale Felder</h4></div>

Wie bereits angemerkt, kennt Java keine mehrdimensionalen Felder. Dennoch können Felder ineinander verschachtelt werden, um so eine analoge Struktur zu erhalten. Ein zweidimensionales Feld ist dabei mit einer Tabelle vergleichbar, wobei das erste (äußere) indizierende Feld auf die Zeile verweisen würde. Die Zeile selbst ist wiederum ein Feld, dessen Indizes auf die Spalte der Zeile, also auf den entsprechenden Eintrag, verweist, wie es auch in der Abbildung ersichtlich ist.

In Java können mehrdimensionale Felder durch die Angabe mehrerer eckiger Klammerpaare <code>[]</code> realisiert werden, wobei jedes Paar für eine weitere Dimension des Feldes steht. Das äußere Feld, welches das nächstinnere indiziert, steht dabei auf der linken Seite, bzw. ist das Klammerpaar, das als erstes definiert wurde. Dies ist am Beispiel eines Bildes ersichtlich, das üblicherweise mit <code>[y][x]</code> indiziert werden würde, wobei hier zunächst die Zeile (y) ermittelt wird und anschließend die Spalte (x) aus der Zeile.

Beispiel der Erstellung eines zweidimensionalen Feldes

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>double[][] feld = new double[zeilen][spalten];

</pre></div>

Bei diesem Beispiel ist zu beachten, dass nicht nur das äußere Feld (hier feld genannt) allokiert wird, sondern auch die Felder für die „Zeilen“. Sie sind also nicht null und wurden ebenfalls mit angelegt. Ihre Einträge werden, wie von einem eindimensionalen Feld zu erwarten, mit 0 initialisiert.

In einer <a href="Matrix_(Mathematik)" title="Matrix (Mathematik)">Matrix</a> werden die waagrechten Felder als Zeilen, die Senkrechten als Spalten bezeichnet. Ein einzelnes Element ist durch den jeweiligen Zeilen- und Spaltenindex eindeutig bestimmt. Die Syntax für eine Matrix oder allgemein für mehrdimensionale Felder ist fast identisch. Der Unterschied liegt in der Anzahl der geschlossenen eckigen Klammern, die Auskunft darüber geben, wie viele Dimensionen das Feld haben wird.

Beispiel der Erstellung eines zweidimensionalen Feldes mit unterschiedlichen Größen in den „Unterfeldern“

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>double[][] feld = new double[3][];

feld[0] = new double[3];

feld[1] = new double[2];

feld[2] = new double[1];

</pre></div>

Bei diesem Beispiel ist zu beachten, dass im ersten Befehl nur das äußere Feld (hier feld genannt) allokiert wird und die einzelnen Elemente mit null initialisiert werden. In den folgenden Befehlen werden diesen Elementen dann die „Unterfelder“ zugewiesen, es ergibt sich hier ein „dreieckiges“ Feld.

Wie bei eindimensionalen Arrays gibt es auch bei mehrdimensionalen Arrays eine verkürzte Variante:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[][] array2D={{1,2,3},{4,5,6}};

//Entspricht "=new int[2][3];" mit den darauf folgenden Zuweisungen

//"array2D[0][0]=1;"

//"array2D[0][1]=2;"

//(...)

//"array2D[1][2]=6;"

</pre></div>

Wo die eckigen Klammern ([]) gesetzt werden, bleibt dem Programmierer überlassen:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int[][] A

</pre></div>

ist das Gleiche wie

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int A[][]

</pre></div>

oder auch

</pre></div>

Allgemeine Syntax

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><Datentyp> []… <Feldvariable> = new <Datentyp> [<Anzahl>]… ;

</pre></div>

Die <a href="Auslassungspunkte" title="Auslassungspunkte">Auslassungspunkte</a> ‘…’ stehen hier stellvertretend für weitere Klammerpaare, die jeweils eine weitere Dimension erzeugen. Der Zugriff auf die Elemente erfolgt analog zu denen eines eindimensionalen Feldes. Dabei ist jedoch zu beachten, dass auch auf das jeweilige äußere Feld zugegriffen werden kann, um z. B. die Anzahl der Zeilen zu bestimmen. Ausgehend vom Beispiel eines zweidimensionalen Feldes kann die Anzahl wie folgt bestimmt werden.

Auslesen und zuweisen von Werten

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>double wert = feld[y][x]; // liefert den Wert des Feldes x,y

feld[y][x] = wert; // weist dem Feld x,y einen Wert zu

</pre></div>

Bestimmung der Länge des Feldes und der Unterfelder

</pre></div>

Die Länge der Unterfelder kann über den Index des Feldes bestimmt werden.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int spaltenanzahl = feld[index].length; // weist der Variable "spaltenanzahl" den Wert von "feld[index].length" zu

</pre></div>

In Langform, bzw. nach einzelnen Schritten aufgelöst, würde dies wie folgt aussehen. Daraus wird ebenfalls ersichtlich, dass es sich bei den Zeilen um Objekte – eindimensionale Felder – handelt.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>double[] zeilenfeld = feld[index]; // ermittelt das erste "Unterfeld" mit gegebenen Index

int spaltenanzahl = zeilenfeld.length; // weist der Variable "spaltenanzahl" den Wert von "zeilenfeld.length" zu

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Anweisungen_und_Kontrollstrukturen">Anweisungen und Kontrollstrukturen</h3></div>

Java unterstützt die üblichen Anweisungen, die auch aus anderen imperativen Programmiersprachen bekannt sind. Einfache Anweisungen werden mit <a href="Semikolon" title="Semikolon">Semikolon</a> abgeschlossen. Mehrere Anweisungen können mit geschweiften Klammern zu einem Anweisungsblock zusammengefasst werden. Kontrollstrukturen werden ebenfalls wie Blöcke behandelt und müssen (bis auf eine Ausnahme) daher nicht mit einem Semikolon abgeschlossen werden.

Als <a href="Kontrollstruktur" title="Kontrollstruktur">Kontrollstrukturen</a> stehen die <a href="Bedingte_Anweisung_und_Verzweigung" title="Bedingte Anweisung und Verzweigung">Bedingte Anweisung und Verzweigung</a> und <a href="Case-Anweisung" class="mw-redirect" title="Case-Anweisung">Case-Anweisung</a>, sowie die <a href="While-Schleife" class="mw-redirect" title="While-Schleife">While</a>-, <a href="Do-while-Schleife" class="mw-redirect" title="Do-while-Schleife">Do-while</a>- und <a href="For-Schleife" title="For-Schleife">For</a>-Schleife und ihre verschiedenen Ausprägungen zur Verfügung.

<div class="mw-heading mw-heading4"><h4 id="Bedingte_Anweisung_und_Verzweigung">Bedingte Anweisung und Verzweigung</h4></div>

Die <a href="Bedingte_Anweisung_und_Verzweigung" title="Bedingte Anweisung und Verzweigung">Bedingte Anweisung und Verzweigung</a>, im Folgenden If-Anweisung genannt, ermöglicht es Anweisungen unter Voraussetzung einer bestimmten Bedingung ausführen zu lassen. Dazu wird das Schlüsselwort „if“ verwendet. Dahinter folgt ein Paar von runden Klammern, in dem die Bedingung definiert werden kann. Die Bedingung ist ein Ausdruck der als Ergebnis einen booleschen Wert (true oder false) liefern muss. Dies unterscheidet Java von anderen Sprachen wie etwa C, bei denen auch andere Werte als Bedingung erlaubt sind. Weiterhin ist anzumerken, dass das häufig anzutreffende Schlüsselwort „then“ nicht existiert.

Das Schlüsselwort „else“ kann verwendet werden um eine Anweisung im Falle des Nichtzutreffens der Bedingung auszuführen. Es ist optional und in diesem Fall spricht man von einer Verzweigung, da entweder die erste oder die zweite Anweisung ausgeführt wird. Alternativ kann anstatt „else“ ein „else if“ verwendet werden, das wie ersteres „if“ eine weitere Bedingung erwartet. Dadurch ist möglich Kaskaden von Verzweigungen aufzubauen. Ohne Strukturierung durch Blöcke (geschweifte Klammern) besteht jedoch die Gefahr eines <a href="Dangling_else" title="Dangling else">Dangling else</a>, bei dem nicht eindeutig ist, welcher If-Anweisung der Else-Zweig zuzuordnen ist.

Allgemeine Syntax

<Anweisung>;

else

<Anweisung>;

</pre></div>

Beispiel für eine einfache If-Anweisung mit einem Block von zwei Ausgaben

System.out.print("Die Zahl ist negativ"); // Bedingte Ausgabe

}

</pre></div>

Komplexeres Beispiel

}

else if (i == 0) {

}

else if (i < 5) {

}

else {

System.out.print("Die Zahl ist größer oder gleich 5");

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Der_Ternäre_Operator">Der Ternäre Operator</h4></div>

Für eine einfache If-Anweisung existiert eine zusätzliche Kurzschreibweise. Diese kann innerhalb eines Ausdrucks verwendet werden, ist aber auf ein „Entweder-oder“ beschränkt. D. h. sie muss in jedem Fall einen konkreten Wert zurückliefern. Der Operator selbst ist das Fragezeichen ‘?’ vor dem ein boolescher Ausdruck stehen muss. Hinter dem Fragezeichen folgt der Rückgabewert für den Fall, dass der boolesche Ausdruck wahr (true) ist. Anschließend folgt ein Doppelpunkt ‘:’ nach dem wiederum der Rückgabewert folgen muss, falls der boolesche Ausdruck nicht wahr (false) ist.

Syntax

</pre></div>

Beispiel

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int a = (i<0) ? -i : i; // kehrt vor der Zuweisung an a das Vorzeichen von i um, wenn i negativ ist (Betrag von i)

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Switch-Anweisung">Switch-Anweisung</h4></div>

<ul><li>Eine Fallunterscheidung, wobei der Ausdruck ein Zeichen, eine Ganzzahl, eine Zeichenkette oder ein Aufzählungstyp sein kann.</li></ul>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>switch (''Ausdruck'') {

case ''Konstante1'': ''Anweisung1''; break;

case ''Konstante2'': ''Anweisung2''; break;

default: ''Anweisung3'';

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Schleifen">Schleifen</h4></div>

Java unterscheidet vier verschiedene Arten von <a href="Schleife_(Programmierung)" title="Schleife (Programmierung)">Schleifen</a>.

<div class="gallerytext">Struktogramm: While-Schleife</div>

</li>

<div class="gallerytext">Struktogramm: Do-while-Schleife</div>

</li>

<div class="gallerytext">Struktogramm: For-Schleife</div>

</li>

</ul>

<ul><li>Wiederhole eine Anweisung solange die Bedingung wahr ist, wobei die Bedingung vor der Anweisung geprüft wird (<a href="While-Schleife" class="mw-redirect" title="While-Schleife">While-Schleife</a>).</li></ul>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>while (''Bedingung'') ''Anweisung'';

</pre></div>

<ul><li>Wiederholung einer Anweisung solange die Bedingung wahr ist, wobei die Bedingung erst nach der Ausführung geprüft wird (<a href="Do-while-Schleife" class="mw-redirect" title="Do-while-Schleife">Do-while-Schleife</a>).</li></ul>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>do ''Anweisung''; while (''Bedingung'');

</pre></div>

<ul><li>Initialisiert einen Wert, wiederholt die Anweisung solange die Bedingung wahr ist und führt eine zweite Anweisung nach jedem Schleifendurchlauf aus (<a href="For-Schleife" title="For-Schleife">For-Schleife</a>).</li></ul>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>for (''Initialisierung''; ''Bedingung''; ''Anweisung2'') ''Anweisung1'';

</pre></div>

<ul><li>Zudem existiert eine erweiterte For-Schleife, auch Foreach-Schleife genannt, die es erlaubt, für jedes Element eines iterierbaren Objektes (<a href="Feld_(Datentyp)" class="mw-redirect" title="Feld (Datentyp)">Reihungen</a>, <a href="Liste_(Datenstruktur)" title="Liste (Datenstruktur)">Listen</a> etc.) Anweisungen auszuführen.</li></ul>

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>for (''Element'' : ''Kollektion'') ''Anweisung'';

</pre></div>

Die nachfolgenden Beispiele zeigen den Einsatz einer solchen erweiterten For-Schleife, einmal angewendet auf den Basisdatentyp <a href="#Primitive_Datentypen"><code>char</code></a> und einmal auf eine Liste.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>char[] chars = new char[] { 'a', 'b', 'c' }; // neues Zeichen-Array anlegen

for (char c : chars) {

System.out.println("Zeichen: " + c); // Jedes Zeichen auf die Konsole schreiben.

}

List<Character> charlist = new ArrayList<Character>(); // neue Zeichen-Liste anlegen

charlist.add('a'); // Werte hinzufügen (mit Autoboxing)

charlist.add('b');

charlist.add('c');

for (Character c : charlist) {

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Ausdrücke">Ausdrücke</h3></div>

Im Gegensatz zu anderen Programmiersprachen, wie beispielsweise <a href="C_(Programmiersprache)" title="C (Programmiersprache)">C</a>, ist die Reihenfolge der Auswertung von Ausdrücken in Java bereits in der Sprachdefinition festgelegt: Binäre infix-Operatoren gleichen <a href="Operatorrangfolge" title="Operatorrangfolge">Rangs</a>, die keine Zuweisungsoperatoren sind, werden immer von links nach rechts ausgewertet. Außerdem gilt – wie in C auch – dass die Auswertung von logischen Ausdrücken verkürzt werden kann, wenn das Ergebnis bereits feststeht. Im folgenden Beispiel wird also garantiert zuerst überprüft, ob „<code>objekt</code>“ nicht „<code>null</code>“ ist. Ist dieser Teilausdruck false (also <code>objekt</code> ist eine Nullreferenz), wird der rechte Operand von <code>&&</code> gar nicht ausgewertet, d. h. die Methode <code>inOrdnung()</code> wird nicht gesucht oder gar gerufen. Somit ist der Gesamtausdruck sicher und kann niemals eine „<code>NullPointerException</code>“ verursachen. (Eine „<code>NullPointerException</code>“ wird in Java immer dann geworfen, wenn versucht wird, die Objektreferenz „<code>null</code>“ aufzulösen.)

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>if (objekt != null && objekt.inOrdnung()) {

}

else {

}

</pre></div>

Werden statt der logischen Operatoren <code>&&</code> und <code>||</code> die Bit-Operatoren <code>&</code> und <code>|</code> verwendet, so müssen beide Teilergebnisse bitweise verknüpft werden und die Verarbeitung kann nicht beim linken Ausdruck abbrechen, falls der <code>false</code> ist. Hat also die Variable <code>objekt</code> den Wert <code>null</code>, so versucht die Java-VM, den aus dem ersten Ausdruck resultierenden Wert <code>false</code> mit dem Ergebnis des zweiten Ausdrucks bitweise zu verknüpfen. Um den zweiten Ausdruck zu berechnen, versucht die VM <code>objekt</code> zu dereferenzieren und wirft eine <code>NullPointerException</code>.

<div class="mw-heading mw-heading4"><h4 id="Funktionale_Schnittstellen_und_Lambda-Ausdrücke">Funktionale Schnittstellen und Lambda-Ausdrücke</h4></div>

Ein Lambda-Ausdruck ist eine namenlose (anonyme) Methode, die (als Objekt) weitergegeben werden kann. Lambda-Ausdrücke beschreiben also Funktionsobjekte. Der Begriff geht auf den <a href="Lambda-Kalk%C3%BCl" title="Lambda-Kalkül">Lambda-Kalkül</a> zurück, eine <a href="Formale_Sprache" title="Formale Sprache">formale Sprache</a> zur Untersuchung von <a href="Funktion_(Mathematik)" title="Funktion (Mathematik)">Funktionen</a> (siehe auch <a href="Funktionale_Programmierung" title="Funktionale Programmierung">funktionale Programmierung</a>). Lambda-Ausdrücke in Java gibt es seit Java 8 und umfassen Parameterlisten, einen Rückgabetyp und einen Body:

(<Datentyp> <Variablenbezeichner>,...,<Datentyp> <Variablenbezeichner>) -> <Ausdruck>

(<Variablenbezeichner>,...,<Variablenbezeichner>) -> <Anweisungsblock>

</pre></div>

Die runden Klammern können weggelassen werden, wenn die Anzahl der enthaltenen Elemente genau eins ist. Die Angabe der Parametertypen ist nur dann erforderlich, wenn der Compiler sie nicht selbst aus dem Kontext des Ausdrucks ableiten kann.<a href="#cite_note-5">[3]</a> Eine Funktion, die die Summe von zwei Argumenten liefert, lässt sich folgendermaßen ausdrücken:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>(i,j) -> i+j

</pre></div>

Sie haben selbst keinen konkreten Typ und können daher nur in einem Kontext verwendet werden, der einen Typ vorgibt, etwa Methodenaufrufe, Return-Anweisungen und Variableninitialisierungen. Der vorgegebene Typ muss eine funktionale Schnittstelle sein. In folgendem Beispiel ist ein <code>Comparator<String></code>-Objekt mit Hilfe eines Lambda-Ausdrucks definiert. Der <code>sort</code>-Aufruf bewirkt die Sortierung von <code>someStrings</code> nach deren Länge, in absteigender Reihenfolge.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>List<String> someStrings = ...

Collections.sort(someStrings, (x,y) -> y.length() - x.length());

</pre></div>

Lambda-Ausdrücke helfen, die oft schlecht lesbaren, langen Deklarationen innerer, anonymer Klassen, zu vermeiden.

In Java heißen Schnittstellen, die nur über eine Operation (abstrakte Methode) verfügen, funktionale Schnittstellen. Eine abstrakte Klasse mit genau einer abstrakten Methode zählt allerdings nicht als funktionale Schnittstelle.

Methodenreferenzen stellen ebenfalls eine ab Java 8 verfügbare Möglichkeit dar, funktionale Schnittstellen zu implementieren. Sie haben eine der Formen

</pre></div>

In folgendem Code wird die Methodenreferenz <code>System.out::println</code> als ein <code>java.util.function.Consumer<String></code>-Objekt verwendet.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>static <A> Consumer<A> doTwice(Consumer<A> consumer) {

return a -> {

consumer.accept(a);

};

}

static void foo() {

doTwice(System.out::println).accept("Hello");

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Kommentare">Kommentare</h3></div>

<a href="Kommentar_(Programmierung)" title="Kommentar (Programmierung)">Kommentare</a> sind Teile des Quellcodes, welche Informationen für den menschlichen Leser enthalten und vom Computer bei der Weiterverarbeitung ignoriert werden.

Man unterscheidet zwischen Zeilenkommentare und Blockkommentare. Der Zeilenkommentar folgt an einer Zeile. Die Syntax besteht aus einem Doppelschrägstrich. Der Blockkommentar umfasst die Beschreibung mehrerer Zeilen. Die Syntax dafür besteht aus einem Schrägstrich und darauf folgendes Mal-Zeichen. Mit dem Mal-Zeichen und dem Schrägstrich wird der Kommentar geschlossen. Beim Kompilieren werden die Kommentare vom Compiler ignoriert.

Beispiel:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre> int i = 10; // Zeilenkommentar: hier bekommt die Variable i den Wert 10 zugewiesen.

int j = 0;

/* Blockkommentar: hier beginnt eine While-Schleife

....

j wird um Eins erhöht, solange j kleiner i ist.*/

while (j < i) {

j++;

}

</pre></div>

Zur Dokumentation ganzer Methoden oder Klassen wird oft das <a href="Javadoc" title="Javadoc">Javadoc</a>-System verwendet.

<div class="mw-heading mw-heading3"><h3 id="Generische_Programmierung">Generische Programmierung</h3></div>

<div class="hauptartikel" role="navigation">→ Hauptartikel: <a href="Generische_Programmierung_in_Java" title="Generische Programmierung in Java">Generische Programmierung in Java</a></div>

Mit Version 5 von Java wurde das Sprachmittel der generischen Programmierung eingeführt.

<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>

<li id="cite_note-1"><a href="#cite_ref-1">↑</a> Scott Stanchfield: <a rel="nofollow" class="external text" href="http://javadude.com/articles/passbyvalue.htm">Java is Pass-by-Value, Dammit!</a> JavaDude.com, abgerufen am 5. November 2010 (englisch).<span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AJava-Syntax&rft.title=Java+is+Pass-by-Value%2C+Dammit%21&rft.description=Java+is+Pass-by-Value%2C+Dammit%21&rft.identifier=http%3A%2F%2Fjavadude.com%2Farticles%2Fpassbyvalue.htm&rft.creator=Scott+Stanchfield&rft.publisher=JavaDude.com&rft.language=en">

</li>

<li id="cite_note-sun-reference-value-2"><a href="#cite_ref-sun-reference-value_2-0">↑</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20120309032412/http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.3.1">Types, Values, and Variables.</a> In: Java Language Specification. Oracle (Sun), archiviert vom <style data-mw-deduplicate="TemplateStyles:r250917974">

/* start https://de.wikipedia.org/ */

.mw-parser-output .dewiki-iconexternal>a{background-position:center right!important;background-repeat:no-repeat!important}body.skin-minerva .mw-parser-output .dewiki-iconexternal>a{background-image:url("./_mw_/OOjs_UI_icon_external-link-ltr-progressive.svg")!important;background-size:10px!important;padding-right:13px!important}body.skin-timeless .mw-parser-output .dewiki-iconexternal>a,body.skin-monobook .mw-parser-output .dewiki-iconexternal>a{background-image:url("./_mw_/MediaWiki_external_link_icon.svg")!important;padding-right:13px!important}body.skin-vector .mw-parser-output .dewiki-iconexternal>a{background-image:url("./_mw_/Link.ernal-small-ltr-progressive.svg")!important;background-size:0.857em!important;padding-right:1em!important}

/* end https://de.wikipedia.org/ */

</style><a class="external text" href="https://redirecter.toolforge.org/?url=http%3A%2F%2Fdocs.oracle.com%2Fjavase%2Fspecs%2Fjls%2Fse5.0%2Fhtml%2FtypesValues.html%234.3.1">Original</a> (nicht mehr online verfügbar) am 9. März 2012; abgerufen am 6. November 2010 (englisch).<span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3AJava-Syntax&rft.title=Types%2C+Values%2C+and+Variables&rft.description=Types%2C+Values%2C+and+Variables&rft.identifier=https%3A%2F%2Fweb.archive.org%2Fweb%2F20120309032412%2Fhttp%3A%2F%2Fdocs.oracle.com%2Fjavase%2Fspecs%2Fjls%2Fse5.0%2Fhtml%2FtypesValues.html%234.3.1&rft.publisher=Oracle+%28Sun%29&rft.source=http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.3.1&rft.language=en">

</li>

<li id="cite_note-5"><a href="#cite_ref-5">↑</a> Martin Gerlach: <a rel="nofollow" class="external text" href="http://blog.neofonie.de/java/java-8-neuheiten-lambda-ausdruecke-und-default-methoden">Java SE 8 Neuerungen (Teil 1): Lambda-Ausdrücke und Default-Methoden</a> In: <a rel="nofollow" class="external text" href="http://blog.neofonie.de/">Neo Tech Blog</a> (erstellt am 17. November 2014, abgerufen am 16. Dezember 2016).

</li>

</ol></div><div><div class="zim-footer">

Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-05-25" href="https://de.wikipedia.org/wiki/?title=Java-Syntax&oldid=256319345">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.

</div>

</div></div>

</div>

</main>

</div>

</body></html>